[Coding005] DataStructure
顺序表的创建与销毁（4种实现方式）

Ben 2023/07/27

More coding records
Get the knowledge flowing and circulating! :)

标题：顺序表的创建与销毁（C语言版）Demo学习主架构代码可完整运行的样例程序A|B|C|D[A段代码]：创建顺序表并测试运行结果[B段代码]：创建顺序表并测试运行结果[C段代码]：创建顺序表并测试运行结果[C段代码]：version2.0 | 创建顺序表并测试运行结果[D段代码]：创建顺序表并测试运行结果★ 整体对比

标题：顺序表的创建与销毁（C语言版）

在数据结构的学习中，最先遇到的就是顺序表！so, 什么是顺序表？
顺序表 (SqList, Sequence List)，即顺序线性表。
顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构，使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。
这里需要注意的是，顺序表的缩写，一般写为SqList. 当然也可以缩写成其他的，本系列程序，我就都写成SqList啦~

Demo学习

主架构代码

解读：这里的代码不能直接运行，因为其中的主要实现没有写出来。
// 【A段代码: 创建顺序表】
// 【B段代码: 创建顺序表】
// 【C段代码: 创建顺序表】
// 【D段代码: 创建顺序表】
为了防止大家看到之后，因为代码过长而退缩，下面我把A段代码提取出来，单独写一下！分为4个程序。
利用【A段代码】并测试；
利用【B段代码】并测试；
利用【C段代码】并测试；
利用【D段代码】并测试；


xxxxxxxxxx
69
1
// 顺序表的创建（C/C++实现）
2
#include"stdio.h"  
3
#include"malloc.h"  // malloc
4

5
#include"stdlib.h"  // exit
6

7
// 下面几行代码中，#define 和 typedef的用法，是不是很熟悉了！
8
// 不熟悉的话，可以看看[Coding004]的内容:)
9
#define List_InitSize 100
10
#define List_Increment 10
11

12
typedef struct{
13
    int *elem;  // 存储空间基址
14
    
15
    int length;  // 当前长度
16
    int listsize; // 当前分配的存储容量(以sizeof(int)为单位)
17
}SqList;
18

19
// 【A段代码: 创建顺序表】
20

21
// 【B段代码: 创建顺序表】
22

23
// 【C段代码: 创建顺序表】
24

25
// 【D段代码: 创建顺序表】
26

27
void DestroyList(SqList *L)
28
{
29
    free(L->elem);      // free((*L).elem);
30
    L->elem = NULL;     // (*L).elem = NULL;  // 置空，防止野指针 
31
    L->length = 0;      // (*L).length = 0; 
32
    L->listsize = 0;    // (*L).listsize = 0; 
33
} 
34

35
int main()
36
{   
37
    // 【A段代码的测试】
38
    SqList* La = Init_SqList01();  // 操作符为 "->" 
39
    printf("La.length=%d, La.listsize=%d\n", La->length, La->listsize);
40
    
41
    // 【B段代码的测试】
42
    SqList Lb = Init_SqList02();  // 操作符为 "." 
43
    printf("Lb.length=%d, Lb.listsize=%d\n", Lb.length, Lb.listsize);
44
    
45
    // 【C段代码的测试】
46
    SqList Lc;  // 操作符为 "." 
47
    Init_SqList03(&Lc);
48
    printf("Lc.length=%d, Lc.listsize=%d\n", Lc.length, Lc.listsize);
49
    
50
    SqList Lc_ret;  // 操作符为 "." 
51
    Init_SqList03(&Lc_ret);
52
    /* 
53
    printf("\n");
54
    printf("Lc_ret.length=%d, Lc_ret.listsize=%d\n", Lc_ret.length, Lc_ret.listsize);
55
    printf("\n");
56
    */ 
57
    
58
    // 【D段代码的测试】
59
    SqList Ld;  // 操作符为 "." 
60
    Init_SqList04(&Ld);
61
    printf("Ld.length=%d, Ld.listsize=%d\n", Ld.length, Ld.listsize);
62
    
63

64
    // 测试 - 销毁函数 
65
    DestroyList(...);
66
    printf("L.length=%d, L.listsize=%d\n", ...); 
67

68
    return 0; 
69
}

可完整运行的样例程序`A`|`B`|`C`|`D`

[A段代码]：创建顺序表并测试


xxxxxxxxxx
49
1
// 顺序表的初始化
2

3
#include"stdio.h"  
4
#include"malloc.h"  // malloc
5

6
#include"stdlib.h"  // exit
7

8
#define List_InitSize 100
9
#define List_Increment 10
10

11
typedef struct{
12
    int *elem;  // 存储空间基址
13
    
14
    int length;  // 当前长度
15
    int listsize; // 当前分配的存储容量(以sizeof(int)为单位)
16
}SqList;
17

18
// 【A段代码】调用示例：SqList* L = Init_SqList01();
19
SqList* Init_SqList01()
20
{
21
    SqList* L = (SqList*)malloc(sizeof(SqList));
22
    
23
    L->elem = (int*)malloc(List_InitSize * sizeof(int));
24
    L->length = 0;
25
    L->listsize = List_InitSize;
26
    
27
    return L;
28
}
29

30
void DestroyList(SqList *L)
31
{
32
    free(L->elem);      // free((*L).elem);
33
    L->elem = NULL;     // (*L).elem = NULL;  // 置空，防止野指针 
34
    L->length = 0;      // (*L).length = 0; 
35
    L->listsize = 0;    // (*L).listsize = 0; 
36
} 
37

38
int main()
39
{   
40
    // 【A段代码的测试】
41
    SqList* La = Init_SqList01();  // 操作符为 "->" 
42
    printf("La.length=%d, La.listsize=%d\n", La->length, La->listsize);
43
    
44
    // 测试 - 销毁函数 
45
    DestroyList(La);
46
    printf("La.length=%d, La.listsize=%d\n", La->length, La->listsize); 
47

48
    return 0; 
49
}

运行结果


xxxxxxxxxx
6
1
La.length=0, La.listsize=100
2
La.length=0, La.listsize=0
3

4
--------------------------------
5
Process exited after 0.02429 seconds with return value 0
6
请按任意键继续. . .

代码解读
A段代码，SqList* Init_SqList01(), 有返回值，且返回的为指针。所以直接调用的时候，用的是箭头符号->，建议大家直接这样记：指针类型用箭头。

[B段代码]：创建顺序表并测试


xxxxxxxxxx
48
1
// 顺序表的初始化
2

3
#include"stdio.h"  
4
#include"malloc.h"  // malloc
5

6
#include"stdlib.h"  // exit
7

8
#define List_InitSize 100
9
#define List_Increment 10
10

11
typedef struct{
12
    int *elem;  // 存储空间基址
13
    
14
    int length;  // 当前长度
15
    int listsize; // 当前分配的存储容量(以sizeof(int)为单位)
16
}SqList;
17

18
// 【B段代码】调用示例：SqList L = Init_SqList02();
19
SqList Init_SqList02()
20
{
21
    SqList L;
22
    L.elem = (int*)malloc(List_InitSize * sizeof(int));
23
    L.length = 0;
24
    L.listsize = List_InitSize;
25
    
26
    return L;
27
}
28

29
void DestroyList(SqList *L)
30
{
31
    free(L->elem);      // free((*L).elem);
32
    L->elem = NULL;     // (*L).elem = NULL;  // 置空，防止野指针 
33
    L->length = 0;      // (*L).length = 0; 
34
    L->listsize = 0;    // (*L).listsize = 0; 
35
} 
36

37
int main()
38
{   
39
    // 【B段代码的测试】
40
    SqList Lb = Init_SqList02();  // 操作符为 "." 
41
    printf("Lb.length=%d, Lb.listsize=%d\n", Lb.length, Lb.listsize);
42
    
43
    // 测试 - 销毁函数 
44
    DestroyList(&Lb);
45
    printf("Lb.length=%d, Lb.listsize=%d\n", Lb.length, Lb.listsize); 
46

47
    return 0; 
48
}

运行结果


xxxxxxxxxx
6
1
Lb.length=0, Lb.listsize=100
2
Lb.length=0, Lb.listsize=0
3

4
--------------------------------
5
Process exited after 0.03558 seconds with return value 0
6
请按任意键继续. . .

代码解读
B段代码，SqList Init_SqList02(), 有返回值，且返回的不是指针。所以直接调用的时候，用的是.

[C段代码]：创建顺序表并测试


xxxxxxxxxx
53
1
// 顺序表的初始化
2

3
#include"stdio.h"  
4
#include"malloc.h"  // malloc
5

6
#include"stdlib.h"  // exit
7

8
#define List_InitSize 100
9
#define List_Increment 10
10

11
typedef struct{
12
    int *elem;  // 存储空间基址
13
    
14
    int length;  // 当前长度
15
    int listsize; // 当前分配的存储容量(以sizeof(int)为单位)
16
}SqList;
17

18
// 【C段代码】调用示例：
19
// SqList l; 
20
// Init_SqList03(&l);
21
void Init_SqList03(SqList *L)
22
{
23
    L->elem = (int*)malloc(List_InitSize * sizeof(int));
24
    if (!L->elem)
25
    {
26
        exit(-2);
27
    }
28
        
29
    L->length = 0;
30
    L->listsize = List_InitSize;
31
}
32

33
void DestroyList(SqList *L)
34
{
35
    free(L->elem);      // free((*L).elem);
36
    L->elem = NULL;     // (*L).elem = NULL;  // 置空，防止野指针 
37
    L->length = 0;      // (*L).length = 0; 
38
    L->listsize = 0;    // (*L).listsize = 0; 
39
} 
40

41
int main()
42
{   
43
    // 【C段代码的测试】
44
    SqList Lc;  // 操作符为 "." 
45
    Init_SqList03(&Lc);
46
    printf("Lc.length=%d, Lc.listsize=%d\n", Lc.length, Lc.listsize);
47
    
48
    // 测试 - 销毁函数 
49
    DestroyList(&Lc);
50
    printf("Lc.length=%d, Lc.listsize=%d\n", Lc.length, Lc.listsize); 
51

52
    return 0; 
53
}

运行结果


xxxxxxxxxx
6
1
Lc.length=0, Lc.listsize=100
2
Lc.length=0, Lc.listsize=0
3

4
--------------------------------
5
Process exited after 0.03225 seconds with return value 0
6
请按任意键继续. . .

代码解读
C段代码，void Init_SqList03(SqList *L), 没有返回值，需要传入参数，且传入的是一个地址。用该函数处理完后，即可直接使用传入的变量。

[C段代码]：version2.0 | 创建顺序表并测试


xxxxxxxxxx
55
1
// 顺序表的初始化
2

3
#include"stdio.h"  
4
#include"malloc.h"  // malloc
5

6
#include"stdlib.h"  // exit
7

8
#define List_InitSize 100
9
#define List_Increment 10
10

11
typedef struct{
12
    int *elem;  // 存储空间基址
13
    
14
    int length;  // 当前长度
15
    int listsize; // 当前分配的存储容量(以sizeof(int)为单位)
16
}SqList;
17

18
// 【C段代码】version2.0
19
// 有return语句和没有return语句的区别，你能看得出来吗？ 
20
int Init_SqLite03_ret(SqList *L)
21
{
22
    L->elem = (int*)malloc(List_InitSize * sizeof(int));
23
    if (!L->elem)
24
    {
25
        exit(-2);
26
    }
27
    
28
    L->length = 0;
29
    L->listsize = List_InitSize;
30
    
31
    return 0;
32
 } 
33

34
void DestroyList(SqList *L)
35
{
36
    free(L->elem);      // free((*L).elem);
37
    L->elem = NULL;     // (*L).elem = NULL;  // 置空，防止野指针 
38
    L->length = 0;      // (*L).length = 0; 
39
    L->listsize = 0;    // (*L).listsize = 0; 
40
} 
41

42
int main()
43
{   
44
    // 【C段代码的测试】version2.0
45
    SqList Lc_ret;  // 操作符为 "." 
46
    Init_SqLite03_ret(&Lc_ret);
47
    printf("Lc_ret.length=%d, Lc_ret.listsize=%d\n", Lc_ret.length, Lc_ret.listsize);
48
    printf("\n");
49
    
50
    // 测试 - 销毁函数 
51
    DestroyList(&Lc_ret);
52
    printf("Lc_ret.length=%d, Lc_ret.listsize=%d\n", Lc_ret.length, Lc_ret.listsize); 
53

54
    return 0; 
55
}

运行结果


xxxxxxxxxx
7
1
Lc_ret.length=0, Lc_ret.listsize=100
2

3
Lc_ret.length=0, Lc_ret.listsize=0
4

5
--------------------------------
6
Process exited after 0.01834 seconds with return value 0
7
请按任意键继续. . .

[D段代码]：创建顺序表并测试


xxxxxxxxxx
53
1
// 顺序表的初始化
2

3
#include"stdio.h"  
4
#include"malloc.h"  // malloc
5

6
#include"stdlib.h"  // exit
7

8
#define List_InitSize 100
9
#define List_Increment 10
10

11
typedef struct{
12
    int *elem;  // 存储空间基址
13
    
14
    int length;  // 当前长度
15
    int listsize; // 当前分配的存储容量(以sizeof(int)为单位)
16
}SqList;
17

18
// 【D段代码】调用示例：
19
// SqList l; 
20
// Init_SqList04(&l);
21
void Init_SqList04(SqList *L)
22
{
23
    (*L).elem = (int*)malloc(List_InitSize * sizeof(int));
24
    if (!(*L).elem) 
25
    {
26
        exit(-2);
27
    }
28

29
    (*L).length = 0;
30
    (*L).listsize = List_InitSize;
31
}
32

33
void DestroyList(SqList *L)
34
{
35
    free(L->elem);      // free((*L).elem);
36
    L->elem = NULL;     // (*L).elem = NULL;  // 置空，防止野指针 
37
    L->length = 0;      // (*L).length = 0; 
38
    L->listsize = 0;    // (*L).listsize = 0; 
39
} 
40

41
int main()
42
{   
43
    // 【D段代码的测试】
44
    SqList Ld;  // 操作符为 "." 
45
    Init_SqList04(&Ld);
46
    printf("Ld.length=%d, Ld.listsize=%d\n", Ld.length, Ld.listsize);
47
    
48
    // 测试 - 销毁函数 
49
    DestroyList(&Ld);
50
    printf("Ld.length=%d, Ld.listsize=%d\n", Ld.length, Ld.listsize); 
51

52
    return 0; 
53
}

运行结果


xxxxxxxxxx
6
1
Ld.length=0, Ld.listsize=100
2
Ld.length=0, Ld.listsize=0
3

4
--------------------------------
5
Process exited after 0.03886 seconds with return value 0
6
请按任意键继续. . .

代码解读
D段代码，void Init_SqList04(SqList *L), 没有返回值，需要传入参数，与C段代码不同在于，实现的时候，绕了个弯（由L->elem变为了(*L).elem）。

★ 整体对比

A段代码，SqList* Init_SqList01(), 有返回值，且返回的为指针。所以直接调用的时候，用的是箭头符号->，建议大家直接这样记：指针类型用箭头。
B段代码，SqList Init_SqList02(), 有返回值，且返回的不是指针。所以直接调用的时候，用的是.
C段代码，void Init_SqList03(SqList *L), 没有返回值，需要传入参数，且传入的是一个地址。用该函数处理完后，即可直接使用传入的变量。
D段代码，void Init_SqList04(SqList *L), 没有返回值，需要传入参数，与C段代码不同在于，实现的时候，绕了个弯（由L->elem变为了(*L).elem）。
销毁函数，void DestroyList(SqList *L), malloc对应的是free，传入参数：待销毁顺序表的指针，其他操作表示还原初始状态。

So, 你觉得哪种方式实现起来比较ok? 以后就选那种就行啦！

[Coding005] DataStructure 顺序表的创建与销毁（4种实现方式）

标题：顺序表的创建与销毁（C语言版）

Demo学习

主架构代码

可完整运行的样例程序A|B|C|D

[A段代码]：创建顺序表并测试

运行结果

[B段代码]：创建顺序表并测试

运行结果

[C段代码]：创建顺序表并测试

运行结果

[C段代码]：version2.0 | 创建顺序表并测试

运行结果

[D段代码]：创建顺序表并测试

运行结果

★ 整体对比

[Coding005] DataStructure
顺序表的创建与销毁（4种实现方式）

可完整运行的样例程序`A`|`B`|`C`|`D`